/*
 * Copyright (C) 2008 Google Inc.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */
package com.google.tts;

import com.googlecode.talkingrssreader.talkingrss.R;

import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.content.pm.PackageManager.NameNotFoundException;
import android.os.IBinder;
import android.os.RemoteException;
import android.util.Log;

/**
 * Synthesizes speech from text. This abstracts away the complexities of using
 * the TTS service such as setting up the IBinder connection and handling
 * RemoteExceptions, etc.
 * 
 * The TTS should always be safe the use; if the user does not have the
 * necessary TTS apk installed, the behavior is that all calls to the TTS act as
 * no-ops.
 * 
 * @author clchen@google.com (Charles L. Chen)
 */
public class TTS {
	// This is the minimum version of the TTS service that is needed by this
	// version of the library stub.
	private final static int MIN_VER = 9;

	/**
	 * Called when the TTS has initialized
	 * 
	 * The InitListener must implement the onInit function. onInit is passed the
	 * version number of the TTS library that the user has installed; since this
	 * is called when the TTS has started, it is a good time to make sure that
	 * the user's TTS library is up to date.
	 */
	public interface InitListener {
		public void onInit(int version);
	}

	/**
	 * Called when the TTS has finished speaking by itself (ie, speaking
	 * finished without being canceled).
	 * 
	 * The InitListener must implement the onInit function. onInit is passed the
	 * version number of the TTS library that the user has installed; since this
	 * is called when the TTS has started, it is a good time to make sure that
	 * the user's TTS library is up to date.
	 */
	public interface SpeechCompletedListener {
		public void onSpeechCompleted();
	}

	private ServiceConnection serviceConnection; // Connection needed for the
	// TTS
	private ITTS itts;
	private Context ctx;
	private InitListener cb = null;
	private int version = -1;
	private boolean started = false;
  private boolean disconnected = false;
	private boolean showInstaller = false;
	private TTSVersionAlert versionAlert = null;

	private ITTSCallback ittscallback;
	private SpeechCompletedListener speechCompletedCallback = null;

	/**
	 * The constructor for the TTS.
	 * 
	 * @param context
	 *            The context
	 * @param callback
	 *            The InitListener that should be called when the TTS has
	 *            initialized successfully.
	 * @param displayInstallMessage
	 *            Boolean indicating whether or not an installation prompt
	 *            should be displayed to users who do not have the TTS library.
	 *            If this is true, a generic alert asking the user to install
	 *            the TTS will be used. If you wish to specify the exact message
	 *            of that prompt, please use TTS(Context context, InitListener
	 *            callback, TTSVersionAlert alert) as the constructor instead.
	 */
	public TTS(Context context, InitListener callback,
			boolean displayInstallMessage) {
		showInstaller = displayInstallMessage;
		ctx = context;
		cb = callback;
		if (dataFilesCheck()) {
			initTts();
		}
	}

	/**
	 * The constructor for the TTS.
	 * 
	 * @param context
	 *            The context
	 * @param callback
	 *            The InitListener that should be called when the TTS has
	 *            initialized successfully.
	 * @param alert
	 *            The TTSVersionAlert to be displayed
	 */
	public TTS(Context context, InitListener callback, TTSVersionAlert alert) {
		showInstaller = true;
		versionAlert = alert;
		ctx = context;
		cb = callback;
		if (dataFilesCheck()) {
			initTts();
		}
	}

	public void setOnSpeechCompletedListener(
			final SpeechCompletedListener listener) {
		speechCompletedCallback = listener;
	}

	private boolean dataFilesCheck() {
		if (!ConfigurationManager.allFilesExist()) {
			// Treat missing voice data as the same as not having the TTS
			// installed.
			// If the developer wants to fail quietly, then just quit if there
			// are
			// missing voice data files.
			if (!showInstaller) {
				return false;
			}
			try {
				int flags = Context.CONTEXT_INCLUDE_CODE
						| Context.CONTEXT_IGNORE_SECURITY;
				Context myContext = ctx.createPackageContext("com.googlecode.talkingrssreader.talkingrss",
						flags);
				Class<?> appClass = myContext.getClassLoader().loadClass(
						"com.google.tts.ConfigurationManager");
				Intent intent = new Intent(myContext, appClass);
				ctx.startActivity(intent);
				return false;
			} catch (NameNotFoundException e) {
				// Just let it fail through; this exception means that the
				// TTS apk has not been installed and this case will be handled
				// in the initTts function
				e.printStackTrace();
			} catch (ClassNotFoundException e) {
				e.printStackTrace();
			}
		}
		return true;
	}

	private void initTts() {
		started = false;

		// Initialize the TTS, run the callback after the binding is successful
		serviceConnection = new ServiceConnection() {
			public void onServiceConnected(ComponentName name, IBinder service) {
        disconnected = false;
				itts = ITTS.Stub.asInterface(service);
				try {
					version = itts.getVersion();
					// The TTS service must be at least the min version needed
					// by the
					// library stub. Do not try to run the older TTS with the
					// newer
					// library stub as the newer library may reference methods
					// which are
					// unavailable and cause a crash.
					if (version < MIN_VER) {
						if (showInstaller) {
							if (versionAlert != null) {
								versionAlert.show();
							} else {
								new TTSVersionAlert(ctx, null, null, null)
										.show();
							}
						}
						return;
					}

					ittscallback = new ITTSCallback.Stub() {
						@Override
						public void markReached(String mark)
								throws RemoteException {
							if (speechCompletedCallback != null) {
								speechCompletedCallback.onSpeechCompleted();
							}
						}
					};
					itts.registerCallback(ittscallback);

				} catch (RemoteException e) {
					initTts();
					return;
				}

				started = true;
				// The callback can become null if the Android OS decides to
				// restart the
				// TTS process as well as whatever is using it. In such cases,
				// do
				// nothing - the error handling from the speaking calls will
				// kick in
				// and force a proper restart of the TTS.
				if (cb != null) {
					cb.onInit(version);
				}
			}

			public void onServiceDisconnected(ComponentName name) {
				itts = null;
				cb = null;
				started = false;
        disconnected = true;
			}
		};

		Intent intent = new Intent("com.googlecode.talkingrssreader.talkingrss.intent.action.USE_SNAPPYTTS");
		intent.addCategory("com.googlecode.talkingrssreader.talkingrss.intent.category.SNAPPYTTS");
		// Binding will fail only if the TTS doesn't exist;
		// the TTSVersionAlert will give users a chance to install
		// the needed TTS.
		if (!ctx.bindService(intent, serviceConnection,
				Context.BIND_AUTO_CREATE)) {
			if (showInstaller) {
				if (versionAlert != null) {
					versionAlert.show();
				} else {
					new TTSVersionAlert(ctx, null, null, null).show();
				}
			}
		}
	}

	/**
	 * Shuts down the TTS. It is good practice to call this in the onDestroy
	 * method of the Activity that is using the TTS so that the TTS is stopped
	 * cleanly.
	 */
	public void shutdown() {
		try {
			ctx.unbindService(serviceConnection);
		} catch (IllegalArgumentException e) {
			// Do nothing and fail silently since an error here indicates that
			// binding never succeeded in the first place.
		}
	}

	/**
	 * Adds a mapping between a string of text and a sound resource in a
	 * package.
	 * 
	 * @see #TTS.speak(String text, int queueMode, String[] params)
	 * 
	 * @param text
	 *            Example: <b><code>"south_south_east"</code></b><br/>
	 * 
	 * @param packagename
	 *            Pass the packagename of the application that contains the
	 *            resource. If the resource is in your own application (this is
	 *            the most common case), then put the packagename of your
	 *            application here.<br/>
	 *            Example: <b>"com.google.marvin.compass"</b><br/>
	 *            The packagename can be found in the AndroidManifest.xml of
	 *            your application.
	 *            <p>
	 *            <code>&lt;manifest xmlns:android=&quot;...&quot;
	 *      package=&quot;<b>com.google.marvin.compass</b>&quot;&gt;</code>
	 *            </p>
	 * 
	 * @param resourceId
	 *            Example: <b><code>R.raw.south_south_east</code></b>
	 */
	public void addSpeech(String text, String packagename, int resourceId) {
		if (!started) {
			return;
		}
		try {
			itts.addSpeech(text, packagename, resourceId);
		} catch (RemoteException e) {
			// TTS died; restart it.
			started = false;
			initTts();
		} catch (NullPointerException e) {
			// TTS died; restart it.
			started = false;
			initTts();
		} catch (IllegalStateException e) {
			// TTS died; restart it.
			started = false;
			initTts();
		}
	}

	/**
	 * Adds a mapping between a string of text and a sound file. Using this, it
	 * is possible to add custom pronounciations for text.
	 * 
	 * @param text
	 *            The string of text
	 * @param filename
	 *            The full path to the sound file (for example:
	 *            "/sdcard/mysounds/hello.wav")
	 */
	public void addSpeech(String text, String filename) {
		if (!started) {
			return;
		}
		try {
			itts.addSpeechFile(text, filename);
		} catch (RemoteException e) {
			// TTS died; restart it.
			started = false;
			initTts();
		} catch (NullPointerException e) {
			// TTS died; restart it.
			started = false;
			initTts();
		} catch (IllegalStateException e) {
			// TTS died; restart it.
			started = false;
			initTts();
		}
	}

	public void addEarcon(String name, String packagename, int resourceId) {
		if (!started) {
			return;
		}
		try {
			itts.addEarcon(name, packagename, resourceId);
		} catch (RemoteException e) {
			// TTS died; restart it.
			started = false;
			initTts();
		} catch (NullPointerException e) {
			// TTS died; restart it.
			started = false;
			initTts();
		} catch (IllegalStateException e) {
			// TTS died; restart it.
			started = false;
			initTts();
		}
	}

	/**
	 * Speaks the string using the specified queuing strategy and speech
	 * parameters. Note that the speech parameters are not universally supported
	 * by all engines and will be treated as a hint. The TTS library will try to
	 * fulfill these parameters as much as possible, but there is no guarantee
	 * that the voice used will have the properties specified.
	 * 
	 * @param text
	 *            The string of text to be spoken.
	 * @param queueMode
	 *            The queuing strategy to use. Use 0 for no queuing, and 1 for
	 *            queuing.
	 * @param params
	 *            The array of speech parameters to be used. Currently, only
	 *            params[0] is defined - it is for setting the type of voice if
	 *            the engine allows it. Possible values are "VOICE_MALE",
	 *            "VOICE_FEMALE", and "VOICE_ROBOT". Note that right now only
	 *            the pre-recorded voice has this support - this setting has no
	 *            effect on eSpeak.
	 */
	public void speak(String text, int queueMode, String[] params) {
    if (disconnected) {
      Log.w("TTSLib", "TTS had disconnected, attempting reconnect");
      initTts();
    }
		Log.i("TTS received: ", text);
		if (!started) {
			return;
		}
		try {
			itts.speak(text, queueMode, params);
		} catch (RemoteException e) {
			// TTS died; restart it.
			started = false;
      disconnected = true;
			initTts();
		} catch (NullPointerException e) {
			// TTS died; restart it.
			started = false;
			initTts();
		} catch (IllegalStateException e) {
			// TTS died; restart it.
			started = false;
			initTts();
		}
	}

	/**
	 * Plays the earcon using the specified queueing mode and parameters.
	 * 
	 * @param earcon
	 *            The earcon that should be played
	 * @param queueMode
	 *            0 for no queue (interrupts all previous utterances), 1 for
	 *            queued
	 * @param params
	 *            An ArrayList of parameters.
	 */
	public void playEarcon(String earcon, int queueMode, String[] params) {
		if (!started) {
			return;
		}
		try {
			itts.playEarcon(earcon, queueMode, params);
		} catch (RemoteException e) {
			// TTS died; restart it.
			started = false;
			initTts();
		} catch (NullPointerException e) {
			// TTS died; restart it.
			started = false;
			initTts();
		} catch (IllegalStateException e) {
			// TTS died; restart it.
			started = false;
			initTts();
		}
	}

	/**
	 * Plays the earcon using the specified queueing mode and parameters.
	 * 
	 * @param earcon
	 *            The TTSEarcon that should be played
	 * @param queueMode
	 *            0 for no queue (interrupts all previous utterances), 1 for
	 *            queued
	 * @param params
	 *            An ArrayList of parameters.
	 */
	public void playEarcon(TTSEarcon earcon, int queueMode, String[] params) {
		playEarcon(earcon.name(), queueMode, params);
	}

	/**
	 * Returns whether or not the TTS is busy speaking.
	 * 
	 * @return Whether or not the TTS is busy speaking.
	 */
	public boolean isSpeaking() {
		if (!started) {
			return false;
		}
		try {
			return itts.isSpeaking();
		} catch (RemoteException e) {
			// TTS died; restart it.
			started = false;
			initTts();
		} catch (NullPointerException e) {
			// TTS died; restart it.
			started = false;
			initTts();
		} catch (IllegalStateException e) {
			// TTS died; restart it.
			started = false;
			initTts();
		}
		return false;
	}

	/**
	 * Stops speech from the TTS.
	 */
	public void stop() {
		if (!started) {
			return;
		}
		try {
			itts.stop();
		} catch (RemoteException e) {
			// TTS died; restart it.
			started = false;
			initTts();
		} catch (NullPointerException e) {
			// TTS died; restart it.
			started = false;
			initTts();
		} catch (IllegalStateException e) {
			// TTS died; restart it.
			started = false;
			initTts();
		}
	}

  public static abstract class TTSUserCallback extends ITTSUserCallback.Stub {
  }

	public void enqueueCallback(TTSUserCallback callback, int user_arg) {
		if (!started) {
			return;
		}
		try {
			itts.enqueueCallback(callback, user_arg);
		} catch (RemoteException e) {
			// TTS died; restart it.
			started = false;
			initTts();
		} catch (NullPointerException e) {
			// TTS died; restart it.
			started = false;
			initTts();
		} catch (IllegalStateException e) {
			// TTS died; restart it.
			started = false;
			initTts();
		}
	}

	/**
	 * Returns the version number of the TTS library that the user has
	 * installed.
	 * 
	 * @return The version number of the TTS library that the user has
	 *         installed.
	 */
	public int getVersion() {
		return version;
	}

	/**
	 * Sets the TTS engine to be used.
	 * 
	 * @param selectedEngine
	 *            The TTS engine that should be used.
	 */
	public void setEngine(TTSEngine selectedEngine) {
		if (!started) {
			return;
		}
		try {
			itts.setEngine(selectedEngine.toString());
		} catch (RemoteException e) {
			// TTS died; restart it.
			started = false;
			initTts();
		}
	}

	/**
	 * Sets the speech rate for the TTS engine.
	 * 
	 * Note that the speech rate is not universally supported by all engines and
	 * will be treated as a hint. The TTS library will try to use the specified
	 * speech rate, but there is no guarantee.
	 * 
	 * Currently, this will change the speech rate for the espeak engine, but it
	 * has no effect on any pre-recorded speech.
	 * 
	 * @param speechRate
	 *            The speech rate for the TTS engine.
	 */
	public void setSpeechRate(int speechRate) {
		if (!started) {
			return;
		}
		try {
			itts.setSpeechRate(speechRate);
		} catch (RemoteException e) {
			// TTS died; restart it.
			started = false;
			initTts();
		}
	}

	/**
	 * Sets the language for the TTS engine.
	 * 
	 * Note that the language is not universally supported by all engines and
	 * will be treated as a hint. The TTS library will try to use the specified
	 * language, but there is no guarantee.
	 * 
	 * Currently, this will change the language for the espeak engine, but it
	 * has no effect on any pre-recorded speech.
	 * 
	 * @param language
	 *            The language to be used. The languages are specified by their
	 *            IETF language tags as defined by BCP 47. This is the same
	 *            standard used for the lang attribute in HTML. See:
	 *            http://en.wikipedia.org/wiki/IETF_language_tag
	 */
	public void setLanguage(String language) {
		if (!started) {
			return;
		}
		try {
			itts.setLanguage(language);
		} catch (RemoteException e) {
			// TTS died; restart it.
			started = false;
			initTts();
		}
	}

	/**
	 * Speaks the given text using the specified queueing mode and parameters.
	 * 
	 * @param text
	 *            The String of text that should be synthesized
	 * @param params
	 *            An ArrayList of parameters. The first element of this array
	 *            controls the type of voice to use.
	 * @param filename
	 *            The string that gives the full output filename; it should be
	 *            something like "/sdcard/myappsounds/mysound.wav".
	 * @return A boolean that indicates if the synthesis succeeded
	 */
	public boolean synthesizeToFile(String text, String[] params,
			String filename) {
		if (!started) {
			return false;
		}
		try {
			return itts.synthesizeToFile(text, params, filename);
		} catch (RemoteException e) {
			// TTS died; restart it.
			started = false;
			initTts();
		} catch (NullPointerException e) {
			// TTS died; restart it.
			started = false;
			initTts();
		} catch (IllegalStateException e) {
			// TTS died; restart it.
			started = false;
			initTts();
		}
		return false;
	}

	/**
	 * Displays an alert that prompts users to install the TTS that is available
	 * on the Market. This is useful if the application expects a newer version
	 * of the TTS than what the user has.
	 */
	public void showVersionAlert() {
		if (!started) {
			return;
		}
		if (versionAlert != null) {
			versionAlert.show();
		} else {
			new TTSVersionAlert(ctx, null, null, null).show();
		}
	}

	/**
	 * Checks if the TTS service is installed or not
	 * 
	 * @return A boolean that indicates whether the TTS service is installed
	 */
	public static boolean isInstalled(Context ctx) {
		PackageManager pm = ctx.getPackageManager();
		Intent intent = new Intent("com.googlecode.talkingrssreader.talkingrss.intent.action.USE_SNAPPYTTS");
		intent.addCategory("com.googlecode.talkingrssreader.talkingrss.intent.category.SNAPPYTTS");
		ResolveInfo info = pm.resolveService(intent, 0);
		if (info == null) {
			return false;
		}
		return true;
	}

}
